#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
@File   : NetworkApi.py
@Time : 2025/2/7 17:00
@Author: Wangwc
@Describe:  网络&安全相关接口封装
"""
import os
import platform
import subprocess
import telnetlib
import tempfile
import time

import paramiko
import requests

from smb.SMBConnection import SMBConnection
from ftplib import FTP, error_perm
import socket
from utils.requests_tools import HttpRequest, check_response, retry_func
from utils.login import Login
from commons.logger import log
from utils.ssh_tools import create_ssh_client
from utils.config_tools import Config
from utils.network_tools import Network
from utils.ssh_tools import create_ssh_client_as_root

# TODO 当前模块的配置文件名称，配置在config目录下
config_name = 'user.ini'
assert_message = {'code': 200, 'msg': 'success'}


class NetworkApi:

    def __init__(self, u_token, configname=config_name):
        self.http = HttpRequest(configname, u_token=u_token)

    @check_response(ext="data", check=assert_message)
    def get_network_general(self):
        """
        获取网络通用设置
        :return:网络通用设置信息
        """
        log.debug(f"开始获取网络通用设置")
        path = "/ugreen/v1/network/general/get"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"在获取网络通用设置过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def set_network_general(self, general: dict, proxy: dict):
        """
        设置网络通用设置
        :param general: 网络通用设置信息 重点设置的key：clash_check、dns_mode、multiple_gateways、prior_ipv4
        :param proxy: 代理设置信息
        """
        log.debug(f"开始设置网络通用设置")
        path = "/ugreen/v1/network/general/set"
        data = {'general': general, 'proxy': proxy}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在设置网络通用设置过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data.result", check=assert_message)
    def set_network_iface(self, interface, mtu_manual=0, mtu=0, vlan=0, status=0, ipv4_protocol="dhcp", ipv4_ipaddr="",
                          ipv4_netmask="", ipv4_gateway="", ipv4_dns=[], ipv4_route=0, ipv6_protocol="disable",
                          ipv6_ipaddr="/", ipv6_gateway="", ipv6_dns=[], ipv6_route=0, ieee8021x_enable=False,
                          ieee8021x_testOnlineEnable=False):
        """
        编辑网络接口
        :param interface: 网口
        """
        log.debug(f"开始编辑网络接口")
        path = "/ugreen/v1/network/iface/set"
        data = {"interface": interface, "mtu": mtu, "mtu_manual": mtu_manual, "vlan": vlan, "status": status,
                "ipv4": {"protocol": ipv4_protocol, "ipaddr": ipv4_ipaddr, "netmask": ipv4_netmask,
                         "gateway": ipv4_gateway, "dns": ipv4_dns, "route": ipv4_route},
                "ipv6": {"protocol": ipv6_protocol, "ipaddr": ipv6_ipaddr, "gateway": ipv6_gateway, "dns": ipv6_dns,
                         "route": ipv6_route},
                "ieee8021x": {"enable": ieee8021x_enable, "testOnlineEnable": ieee8021x_testOnlineEnable}}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在编辑网络接口过程中出现异常，异常信息: {e}")
            raise

    def check_ipv4_prior(self, hostname, username, passwd, command):
        """
        通过SSH终端检查IPV4地址解析域名是否打开
        :param command: 执行的ssh命令
        """
        log.debug(f"开始通过SSH终端检查IPV4地址解析域名是否打开")

        try:
            # 创建 SSH 客户端连接
            ssh = create_ssh_client(hostname, username, passwd)
            # 执行命令
            stdin, stdout, stderr = ssh.exec_command(command)
            # 获取命令执行结果
            output = stdout.read().decode('utf-8')
            # 关闭 SSH 连接
            ssh.close()
            return output
        except Exception as e:
            log.error(f"在通过SSH终端检查IPV4地址解析域名是否打开过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def get_gateway(self):
        """
        获取网关信息
        :return:网关信息
        """
        log.debug(f"开始获取网关信息")
        path = "/ugreen/v1/network/general/gateway_get"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"在获取网关信息过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def set_gateway(self, ipv4, ipv6=[]):
        """
        设置网关信息
        :param ipv4: IPV4地址 列表
        :param ipv6: IPV6地址 列表
        :return:网关信息
        """
        log.debug(f"开始设置网关信息")
        path = "/ugreen/v1/network/general/gateway_set"
        data = {"ipv4": ipv4, "ipv6": ipv6}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在获取网关信息过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data.ifaces", check=assert_message)
    def get_network_iface_list(self, interface='all'):
        """
        获取网卡列表信息
        :param interface:
                // interface键不存在或值为all时表示获取所有接口信息，其它参数据见参数说明否则为指定接口信息
                // valid:  表示获取有效的接口（排除 为桥和bond的成员接口）     用于流管控，防获火墙 接口列表
                // ethernet:  表示获取本设备下所有的以太网接口信息（包括桥和bond的成员接口）
                // valid_eth:  表示有效的以太网接口（返回的数据，非桥和bond成员接口，且为以太网口）， 用于创键bond和桥时的成员接口选择列表
                // eth0,wlan0 : 具体的网卡时就获取具体网卡信息
        :return:网卡列表
        """
        log.debug(f"开始获取网卡列表信息")
        path = "/ugreen/v1/network/iface/list"
        params = {"interface": interface}
        try:
            response = self.http.get(path, params=params)
            return response
        except Exception as e:
            log.error(f"在获取网卡列表信息过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data.ifaces", check=assert_message)
    def get_bond_selectable(self):
        """
        创建bond时获取可选用的网卡
        :return:网卡信息
        """
        log.debug(f"开始获取创建bond时获取可选用的网卡")
        path = "/ugreen/v1/network/bond/selectable"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"在获取创建bond时获取可选用的网卡过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def create_bond(self, slaves, bond_mode="balance-alb", protocol="dhcp", dns=["", ""], route=0):
        """
        创建bond
        :param: slaves: 网卡列表  ["eth0","eth1"]
        :param: bond_mode: bond模式 balance-alb:6、active-backup:1、balance-rr:0、balance-xor:2、802.3ad:4
        :param: protocol: 协议
        :param: dns: dns服务器
        :param: route: 是否为默认网关 0:否 1:是
        :return:网关信息
        """
        log.debug(f"开始创建bond")
        path = "/ugreen/v1/network/bond/create"
        data = {"slaves": slaves, "bond_mode": bond_mode, "ipv4": {"protocol": protocol, "dns": dns, "route": route}}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在创建bond过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def delete_bond(self, interface='bond0'):
        """
        删除bond
        :return:
        """
        log.debug(f"开始执行删除bond操作")
        path = "/ugreen/v1/network/bond/delete"
        data = {"interface": interface}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在删除bond过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data.result", check=assert_message)
    def get_bond_status(self):
        """
        获取bond状态
        :return:bond状态 0初始状态  1操作中  2操作成功  3操作失败
        """
        log.debug(f"开始获取bond状态")
        path = "/ugreen/v1/network/bond/status"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"获取bond状态过程中出现异常，异常信息: {e}")
            raise

    def check_bond_status(self, status, timeout=120):
        """
        校验bond状态并等待固定时间
        """
        log.debug(f"开始校验 bond 状态并等待，预期状态: {status}，最大等待时间: {timeout} 秒")
        try:
            elapsed_time = 0
            while elapsed_time < timeout:
                bond_status = self.get_bond_status()
                log.info(f"当前获取到的 bond 状态为: {bond_status}")
                if bond_status == status:
                    log.debug(f"在 {elapsed_time} 秒内达到预期状态 {status}")
                    return True
                time.sleep(5)
                elapsed_time += 5
                log.info(f"bond 状态为 {bond_status}，等待 5 秒后继续校验，已等待 {elapsed_time} 秒")
            raise TimeoutError(f"等待 {timeout} 秒后仍未达到预期状态 {status}")
        except TimeoutError as e:
            log.error(f"等待超时: {e}")
            raise
        except Exception as e:
            log.error(f"获取 bond 状态过程中出现异常，异常信息: {e}")
            raise

    def get_nasname_by_ip(self, ip):
        """
        根据 IP 获取 nasname
        :param ip:
        :return:
        """
        path = f"https://{ip}:9443/ugreen/v1/wizard/is_initialize?"
        log.info(f"开始尝试从 IP {ip} 获取 nasname，请求路径为 {path}")

        try:
            log.debug(f"正在向 {path} 发送 GET 请求，超时时间设置为 0.1 秒，忽略 SSL 验证")
            response = requests.get(path, timeout=0.1, verify=False)
            log.debug(f"收到来自 {path} 的响应，状态码为 {response.status_code}")

            if response.status_code == 200:
                log.info(f"IP {ip} 的响应状态码为 200，开始解析 JSON 数据")
                nasname = response.json().get('data', {}).get('device_name')
                if nasname:
                    log.info(f"成功从 IP {ip} 获取到 nasname: {nasname}")
                else:
                    log.warning(f"IP {ip} 的响应状态码为 200，但未找到有效的 nasname")
                return nasname
            else:
                log.warning(f"IP {ip} 的响应状态码不为 200，实际状态码为 {response.status_code}，无法获取 nasname")
                return None
        except requests.exceptions.Timeout:
            log.warning(f"请求 IP {ip} 超时，超时时间为 0.1 秒，无法获取 nasname")
            return None
        except requests.exceptions.RequestException as e:
            log.error(f"请求 IP {ip} 时发生网络错误，异常信息: {e}，无法获取 nasname")
            return None
        except ValueError as e:
            log.error(f"解析 IP {ip} 的响应 JSON 数据时发生错误，异常信息: {e}，无法获取 nasname")
            return None
        except Exception as e:
            log.critical(f"发生未知错误，IP: {ip}，异常信息: {e}，无法获取 nasname")
            return None

    def get_ip_by_prefix(self, network_prefix, nasname):
        """
        根据网段前缀和 nasname 获取匹配的 IP 地址
        :param network_prefix: 网络前缀，如 172.17.20
        :param nasname: 设备名称
        :return: 匹配的 IP 地址，如果未找到则返回 None
        """
        log.info(f"开始根据网段前缀 {network_prefix} 和 nasname {nasname} 查找匹配的 IP 地址")
        ips = [f"{network_prefix}.{i}" for i in range(1, 256)]
        total_ips = len(ips)
        log.info(f"生成了 {total_ips} 个可能的 IP 地址进行检查")

        for index, ip in enumerate(ips, start=1):
            log.info(f"正在检查第 {index}/{total_ips} 个 IP 地址: {ip}")
            name = self.get_nasname_by_ip(ip)
            if name and name == nasname:
                log.info(f"找到匹配的 IP 地址: {ip}，对应的 nasname 为 {nasname}")
                return ip
            else:
                log.info(f"IP 地址 {ip} 未匹配到目标 nasname {nasname}")

        log.info(f"遍历完所有 {total_ips} 个 IP 地址后，未找到与 nasname {nasname} 匹配的 IP 地址")
        return None

    @check_response(ext="data.result", check=assert_message)
    def create_virtual(self, interfaces):
        """
        创建虚拟桥接网络
        :param: interfaces: 网卡列表  ["eth0","eth1"]
        :return:
        """
        log.debug(f"开始创建虚拟桥接网络")
        path = "/ugreen/v1/network/bridge/create_virtual"
        data = {"interfaces": interfaces}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在创建虚拟桥接网络过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data.result", check=assert_message)
    def delete_virtual(self, interface):
        """
        删除虚拟桥接网络
        :param: interface：bridge1
        :return:
        """
        log.debug(f"开始删除虚拟桥接网络")
        path = "/ugreen/v1/network/bridge/delete"
        data = {"interface": interface}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在删除虚拟桥接网络过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data.status", check=assert_message)
    def get_virtual_status(self):
        """
        获取桥接网络状态
        :return:bond状态 0初始状态  1操作中  2操作成功  3操作失败
        """
        log.debug(f"开始获取桥接网络状态")
        path = "/ugreen/v1/network/bridge/status_virtual"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"获取桥接网络状态过程中出现异常，异常信息: {e}")
            raise

    def check_virtual_status(self, status, timeout=30):
        """
        校验桥接网络状态并等待固定时间
        """
        log.debug(f"开始校验桥接网络状态并等待，预期状态: {status}，最大等待时间: {timeout} 秒")
        try:
            elapsed_time = 0
            while elapsed_time < timeout:
                virtual_status = self.get_virtual_status()
                log.info(f"当前获取到的桥接网络状态为: {virtual_status}")
                if virtual_status == status:
                    log.debug(f"在 {elapsed_time} 秒内达到预期状态 {status}")
                    return True
                time.sleep(5)
                elapsed_time += 5
                log.info(f"桥接网络状态为 {virtual_status}，等待 5 秒后继续校验，已等待 {elapsed_time} 秒")
            raise TimeoutError(f"等待 {timeout} 秒后仍未达到预期状态 {status}")
        except TimeoutError as e:
            log.error(f"等待超时: {e}")
            raise
        except Exception as e:
            log.error(f"获取桥接网络状态过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data.result", check=assert_message)
    def get_bridge_status(self):
        """
        获取桥接网络状态
        :return:bond状态 0初始状态  1操作中  2操作成功  3操作失败
        """
        log.debug(f"开始获取桥接网络状态")
        path = "/ugreen/v1/network/bridge/status"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"获取桥接网络状态过程中出现异常，异常信息: {e}")
            raise

    def check_bridge_status(self, status, timeout=30):
        """
        校验桥接网络状态并等待固定时间
        """
        log.debug(f"开始校验桥接网络状态并等待，预期状态: {status}，最大等待时间: {timeout} 秒")
        try:
            elapsed_time = 0
            while elapsed_time < timeout:
                bridge_status = self.get_bridge_status()
                log.info(f"当前获取到的桥接网络状态为: {bridge_status}")
                if bridge_status == status:
                    log.debug(f"在 {elapsed_time} 秒内达到预期状态 {status}")
                    return True
                time.sleep(5)
                elapsed_time += 5
                log.info(f"桥接网络状态为 {bridge_status}，等待 5 秒后继续校验，已等待 {elapsed_time} 秒")
            raise TimeoutError(f"等待 {timeout} 秒后仍未达到预期状态 {status}")
        except TimeoutError as e:
            log.error(f"等待超时: {e}")
            raise
        except Exception as e:
            log.error(f"获取桥接网络状态过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data.list", check=assert_message)
    def get_network_flow(self):
        """
        获取流量控制信息
        :return:
        """
        log.debug(f"开始获取流量控制信息")
        path = "/ugreen/v1/network/flow/get"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"在获取流量控制信息过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def set_network_flow(self, list):
        """
        设置流量控制
        :param list: 网络限流列表 [{"type":"all","interface":"all","min_rate":10,"max_rate":10240,"ports":"all","enable":1,"target":"src"}]
        :return:网关信息
        """
        log.debug(f"开始设置流量控制信息")
        path = "/ugreen/v1/network/flow/set"
        data = {"list": [{"interface": "all", "list": list}]}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在设置流量控制过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def clear_network_flow(self):
        """
        清空流量控制设置
        """
        log.debug(f"开始设置流量控制信息")
        path = "/ugreen/v1/network/flow/set"
        data = {"list": []}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在清空流量控制设置过程中出现异常，异常信息: {e}")
            raise

    def find_unused_ip(self, network_prefix='172.17.20', timeout=5):
        system = platform.system()
        for i in range(1, 256):
            ip = f"{network_prefix}.{i}"
            try:
                if system == "Linux":
                    result = subprocess.call(['ping', '-c', '2', '-W', str(timeout), ip], stdout=subprocess.DEVNULL,
                                             stderr=subprocess.DEVNULL)
                    if result != 0:
                        return ip
                elif system == "Windows":
                    output = subprocess.run(['ping', '-n', '2', '-w', str(timeout * 1000), ip], capture_output=True,
                                            text=True)
                    if "Request timed out." in output.stdout:
                        return ip
            except Exception as e:
                print(f"执行 ping 命令时出现错误: {e}")
        return None

    @check_response(ext="data", check=assert_message)
    def get_security_common_config(self):
        """
        读取安全性常规配置
        """
        log.debug(f"开始读取安全性常规配置")
        path = "/ugreen/v1/security/common/config"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"在读取安全性常规配置过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def set_security_common_config(self, login_timeout_enable=1, login_timeout=30, clear_ugreen_token=1, csp_enable=1,
                                   csrf_enable=1, iframe_enable=0, tls_option_enable=1, tls_version="1.2",
                                   tls_list=["1.0", "1.1", "1.2", "1.3"], doc_sec_enable=1, block_config_enable=1,
                                   interval=5,
                                   try_times=10, enable_release_lock=1, block_days=1):
        """
        设置安全性常规配置
        """
        log.debug(f"开始设置安全性常规配置")
        path = "/ugreen/v1/security/common/config"
        data = {"login_config": {"login_timeout_enable": login_timeout_enable, "login_timeout": login_timeout,
                                 "clear_ugreen_token": clear_ugreen_token},
                "nginx_sec_config": {"csp_enable": csp_enable, "csrf_enable": csrf_enable,
                                     "iframe_enable": iframe_enable, "tls_option_enable": tls_option_enable,
                                     "tls_version": tls_version, "tls_list": tls_list},
                "doc_sec_enable": doc_sec_enable,
                "block_config": {"enable": block_config_enable, "interval": interval, "try_times": try_times,
                                 "enable_release_lock": enable_release_lock,
                                 "block_days": block_days}}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在设置安全性常规配置过程中出现异常，异常信息: {e}")
            raise

    def check_dos_protection(self, host, username, password):
        try:
            # 创建 SSH 对象
            ssh = create_ssh_client_as_root(host, username, password)
            # 执行 iptables -L 命令
            stdin, stdout, stderr = ssh.exec_command('iptables -L')
            # 获取命令结果
            output = stdout.read().decode('utf-8')

            # 检查 INPUT 链中是否有 UGDOS_PROTECT 目标规则
            input_chain_lines = output.split('Chain INPUT (policy ACCEPT)\n')[1].split('\n')
            has_ugdos_protect_in_input = any('UGDOS_PROTECT' in line for line in input_chain_lines)

            # 检查 UGDOS_PROTECT 链的引用数和规则内容
            ugdos_protect_chain_start = output.find('Chain UGDOS_PROTECT')
            if ugdos_protect_chain_start != -1:
                ugdos_protect_chain = output[ugdos_protect_chain_start:]
                references_line = ugdos_protect_chain.split('\n')[0]
                references_count = int(references_line.split('(')[1].split(' ')[0])
                has_rules_in_ugdos_protect = len(ugdos_protect_chain.split('\n')[2:]) > 1
            else:
                references_count = 0
                has_rules_in_ugdos_protect = False
            # 判断是否开启 DOS 保护
            is_dos_protection_enabled = has_ugdos_protect_in_input and references_count > 0 and has_rules_in_ugdos_protect
            # 关闭连接
            ssh.close()
            return is_dos_protection_enabled
        except Exception as ex:
            print(f"发生未知错误: {ex}")
        return False

    @check_response(ext="data.result", check=assert_message)
    def get_blocklist(self):
        """
        获取黑名单列表
        """
        log.debug(f"开始获取黑名单列表")
        path = "/ugreen/v1/security/common/blocklist"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"在获取黑名单列表过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def change_blocklist(self, addlist=[], dellist=[]):
        """
        更改黑名单列表
        :param: addlist [{"ip":"172.17.21.125","days":0},{"ip":"172.17.21.25","days":5}]
        :param: dellist []、[id]
        """
        log.debug(f"开始更改黑名单列表")
        path = "/ugreen/v1/security/common/blocklist"
        data = {"add_list": addlist, "del_list": dellist}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在更改黑名单列表过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data.result", check=assert_message)
    def get_whitelist(self):
        """
        获取白名单列表
        """
        log.debug(f"开始获取白名单列表")
        path = "/ugreen/v1/security/common/whitelist"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"在获取白名单列表过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def change_whitelist(self, ip_list=[], dellist=[]):
        """
        更改白名单列表
        :param: addlist [{"ip":"172.17.21.125","days":0},{"ip":"172.17.21.25","days":5}]
        :param: dellist []、[id]
        """
        log.debug(f"开始更改白名单列表")
        path = "/ugreen/v1/security/common/whitelist"
        data = {"ip_rule_list": ip_list, "del_list": dellist}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在更改白名单列表过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def get_firewall_info(self):
        """
        获取防火墙信息
        """
        log.debug(f"开始获取防火墙信息")
        path = "/ugreen/v1/security/firewall/info"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"在获取防火墙信息过程中出现异常，异常信息: {e}")
            raise

    def del_all_firewall_rule(self):
        """
        清空所有的防火墙规则
        :return:
        """
        log.info("开始执行清空所有防火墙规则的操作")
        try:
            log.debug("调用 get_firewall_info 方法获取防火墙信息")
            results = self.get_firewall_info()
            if not isinstance(results, dict) or 'nameList' not in results:
                log.error("获取的防火墙信息格式不正确，缺少 'nameList' 字段")
                return False
            firewall_list = results.get('nameList')
            if not firewall_list:
                log.warning("未获取到任何防火墙规则，无需删除")
                return True
            log.info(f"获取到 {len(firewall_list)} 条防火墙规则，开始逐个删除")
            for firewall in firewall_list:
                log.debug(f"准备删除防火墙规则: {firewall}")
                delete_result = self.del_firewall_rule([firewall])
                if delete_result:
                    log.info(f"成功删除防火墙规则: {firewall}")
                else:
                    log.error(f"删除防火墙规则 {firewall} 失败")
            log.info("所有防火墙规则删除操作完成")
            return True
        except Exception as e:
            log.error(f"在清空防火墙规则过程中出现异常，异常信息: {e}")
            return False


    # 默认的 port_info 配置
    _DEFAULT_PORT_INFO = {"type": "custom","ports": "10254","internal_servers": [],"sections": [],"target": "dest","protocol": "all"}

    # 默认的 host_info 配置
    _DEFAULT_HOST_INFO = {"type": "all","src_ip": ""}

    @check_response(ext="data", check=assert_message)
    def add_firewall_rule(self, **kwargs):
        """
        新增防火墙规则
        """
        log.debug(f"开始新增防火墙规则")
        path = "/ugreen/v1/security/firewall/add"

        # 获取必要参数
        name = kwargs.get('name')
        if not name:
            raise ValueError("参数 'name' 是必需的")

        # 获取其他参数，使用默认值
        id = kwargs.get('id', 0)
        default = kwargs.get('default', 1) # 1表示规则都不符合时允许，0表示规则都不符合时拒绝
        enable = kwargs.get('enable', 1)
        permit = kwargs.get('permit', 1)  # 1表示允许，0表示拒绝
        interface = kwargs.get('interface', "all")
        label = kwargs.get('label', "ALL")
        rule_enable = kwargs.get('rule_enable', 1)

        # 合并 port_info 和 host_info
        port_info = {**self._DEFAULT_PORT_INFO, **kwargs.get('port_info', {})}
        host_info = {**self._DEFAULT_HOST_INFO, **kwargs.get('host_info', {})}

        data = {
            "id": id,
            "name": name,
            "default": default,
            "enable": enable,
            "firewall_rules": [
                {
                    "permit": permit,
                    "interface": interface,
                    "label": label,
                    "port_list": port_info,
                    "host_list": host_info,
                    "enable": rule_enable
                }
            ]
        }

        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在新增防火墙规则过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def firewall_testport(self, id):
        """
        防火墙测试接口
        :param: id 防火墙规则id
        """
        log.debug(f"开始防火墙测试接口")
        path = "/ugreen/v1/security/firewall/testport"
        params = {"id": id}
        try:
            response = self.http.get(path, params=params)
            return response
        except Exception as e:
            log.error(f"在防火墙测试接口过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def set_firewall(self, enable=1, notify=1,nameList=[{"id":1,"name":"防火墙配置1","enable":1}]):
        """
        设置防火墙
        :param enable: 防火墙开关 0：关闭  1：开启
        :param nameList: 防火墙规则列表 从get_firewall_info 方法获取
         示例：[{"id":1,"name":"防火墙配置1","enable":1}]

        """
        log.debug(f"开始设置防火墙")
        path = "/ugreen/v1/security/firewall/set"
        data = {"enable": enable,"notify":notify, "nameList": nameList}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在设置防火墙过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def get_firewall_list(self, id):
        """
        根据防火墙规则id获取防火墙规则
        :param id: 防火墙规则id
        """
        log.debug(f"开始根据防火墙规则id获取防火墙规则")
        path = "/ugreen/v1/security/firewall/list"
        params = {"id": id}
        try:
            response = self.http.get(path, params=params)
            return response
        except Exception as e:
            log.error(f"在根据防火墙规则id获取防火墙规则过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def del_firewall_rule(self, nameList):
        """
        删除防火墙规则
        :param nameList: 防火墙规则列表 从get_firewall_info 方法获取
         示例：[{"id":1,"name":"防火墙配置1","enable":1}]

        """
        log.debug(f"开始删除防火墙规则")
        path = "/ugreen/v1/security/firewall/del"
        data = {"nameList": nameList}
        try:
            response = self.http.post(path, json=data)
            return response
        except Exception as e:
            log.error(f"在删除防火墙规则过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data.result", check=assert_message)
    def get_ssl_list(self):
        """
        获取证书列表
        """
        log.debug(f"开始获取证书列表")
        path = "/ugreen/v1/security/ssl/list"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"在获取证书列表过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def get_ssl_settings(self):
        """
        获取证书设置信息
        """
        log.debug(f"开始获取证书设置信息")
        path = "/ugreen/v1/security/ssl/getsettings"
        try:
            response = self.http.get(path)
            return response
        except Exception as e:
            log.error(f"在获取证书设置信息过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def set_ssl_settings(self,UGREENlink,ftps="UGREEN",webdav="UGREEN",webserver="UGREEN"):
        """
        设置证书设置信息
        :param UGREENlink: UGREENlink  "wang1234.direct-test.ug.link"
        :param ftps: ftps  "UGREEN"
        :param webdav: webdav  "UGREEN"
        :param webserver: webserver  "UGREEN"
        """
        log.debug(f"开始设置证书设置信息")
        path = "/ugreen/v1/security/ssl/settings"
        data = {"UGREENlink":UGREENlink,"ftps":ftps,"webdav":webdav,"webserver":webserver}
        try:
            response = self.http.post(path,json=data)
            return response
        except Exception as e:
            log.error(f"在设置证书设置信息过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def extend_ssl_security(self,cert):
        """
        证书延期
        """
        log.debug(f"开始执行证书延期操作")
        path = "/ugreen/v1/security/ssl/extend"
        params = {"cert":cert}
        try:
            response = self.http.get(path,params=params)
            return response
        except Exception as e:
            log.error(f"在证书延期过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def import_ssl_security(self,pem_file,cert_file,medium_file='',cover=0):
        """
        导入证书
        """
        log.debug(f"开始执行导入证书操作")
        path = "/ugreen/v1/security/ssl/import"
        params = {"cover": cover}
        files = []
        if pem_file:
            files.append(('file', pem_file))
        if cert_file:
            files.append(('file', cert_file))
        if medium_file:
            files.append(('file', medium_file))

        log.info(f"准备导入的文件列表: {files}")
        try:
            response = self.http.post(path, params=params,files=files)
            return response
        except Exception as e:
            log.error(f"在证书延期过程中出现异常，异常信息: {e}")
            raise

    @check_response(ext="data", check=assert_message)
    def del_ssl_security(self, cert_name):
        """
        删除证书
        """
        log.debug(f"开始执行删除证书操作")
        path = "/ugreen/v1/security/ssl/cert/delete"
        params = {"cert": cert_name}
        try:
            response = self.http.delete(path, params=params)
            return response
        except Exception as e:
            log.error(f"在删除证书过程中出现异常，异常信息: {e}")
            raise

    def read_files(self,path):
        """
        读取证书文件并返回二进制数据
        :return: 私钥文件和证书文件的二进制数据
        """
        try:
            with open(path, 'rb') as file:
                data = file.read()
            return data
        except FileNotFoundError:
            raise FileNotFoundError("文件未找到，请检查配置文件中的文件名和路径。")
        except Exception as e:
            raise Exception(f"读取文件时出现错误: {e}")

    def check_http(self,host, username):
        """检查http服务是否可以访问"""
        path = f'http://{host}:9999/ugreen/v1/verify/check'
        data = {
            "username": username
        }
        log.info(f"开始检查 HTTP 服务，请求地址: {path}，请求数据: {data}")
        try:
            # 发送 POST 请求
            log.debug(f"正在发送 POST 请求到 {path}，请求数据: {data}")
            result = requests.post(path, json=data, verify=False)
            log.debug(f"收到响应，状态码: {result.status_code}，响应内容: {result.text}")
            result.raise_for_status()  # 检查请求是否成功
            log.info("HTTP 服务可访问，请求成功")
            return True, "HTTP 服务可访问"
        except requests.ConnectionError as e:
            log.error(f"网络连接出现问题，获取公钥请求失败: {e}，请求地址: {path}，请求数据: {data}")
            return False, "网络连接出现问题"
        except requests.Timeout as e:
            log.error(f"获取公钥请求超时: {e}，请求地址: {path}，请求数据: {data}")
            return False, "请求超时"
        except requests.HTTPError as e:
            log.error(f"HTTP 请求错误: {e}，请求地址: {path}，请求数据: {data}，响应状态码: {e.response.status_code}")
            return False, f"HTTP 请求错误: {e.response.status_code}"
        except Exception as e:
            log.error(f"获取公钥接口出现其他异常: {e}，请求地址: {path}，请求数据: {data}")
            return False, "发生意外错误"

    def check_ssh_login(self, server_ip, username, password, port=22, timeout=5):
        """
        验证 SSH 服务是否可以正常登录
        :param server_ip: SSH 服务器 IP 地址
        :param username: 登录用户名
        :param password: 登录密码
        :param port: SSH 服务端口（默认 22）
        :param timeout: 连接超时时间（秒）
        :return: 元组 (是否成功连接, 返回信息)
        """
        log.info(f"开始验证 SSH 服务登录，服务器 IP: {server_ip}，用户名: {username}，端口: {port}，超时时间: {timeout} 秒")
        try:
            # 创建 SSH 客户端对象
            log.debug("创建 SSH 客户端对象")
            ssh = paramiko.SSHClient()
            ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())  # 自动添加主机密钥
            log.debug("已设置自动添加主机密钥策略")

            # 尝试建立连接
            log.debug(f"尝试连接到 {server_ip}:{port}，使用用户名 {username} 进行认证")
            ssh.connect(server_ip, port=port, username=username, password=password, timeout=timeout)
            log.info("成功连接到 SSH 服务，登录验证通过")

            # 登录成功后关闭连接
            log.debug("登录成功，关闭 SSH 连接")
            ssh.close()
            return (True, "SSH 服务可访问")

        except socket.timeout:
            log.error(f"SSH 连接超时，服务器 IP: {server_ip}，端口: {port}，可能是防火墙阻塞")
            return (False, "SSH 连接超时 (防火墙阻塞?)")
        except paramiko.ssh_exception.NoValidConnectionsError:
            log.error(f"无法连接到 SSH 服务，服务器 IP: {server_ip}，端口: {port}，可能端口关闭或服务未运行")
            return (False, "无法连接到 SSH 服务 (端口关闭或服务未运行)")
        except paramiko.AuthenticationException:
            log.error(f"SSH 认证失败，服务器 IP: {server_ip}，用户名: {username}，可能用户名或密码错误")
            return (False, "认证失败 (用户名或密码错误)")
        except Exception as e:
            log.error(f"发生意外错误，服务器 IP: {server_ip}，端口: {port}，错误信息: {str(e)}")
            return (False, f"发生意外错误: {str(e)}")

    def check_smb_login(self,server_ip, username, password, port=445,timeout=5):
        """
        验证SMB服务器登录状态及防火墙连通性
        :param server_ip: SMB服务器IP地址
        :param username: 登录用户名
        :param password: 登录密码
        :param timeout: 连接超时时间（秒）
        :return: 元组 (是否成功连接, 错误类型)
        """
        log.info(f"开始验证 SMB 服务器登录状态，服务器 IP: {server_ip}，用户名: {username}，超时时间: {timeout} 秒")

        try:
            # 创建SMB连接对象
            log.debug(f"创建 SMB 连接对象，客户端标识名: CLIENT_PC，服务器 IP: {server_ip}")
            conn = SMBConnection(
                username,
                password,
                "CLIENT_PC",  # 客户端标识名（可自定义）
                server_ip,
                use_ntlm_v2=True,
                is_direct_tcp=True
            )

            # 尝试建立连接（端口445）
            log.debug(f"尝试连接到 {server_ip}:445，超时时间: {timeout} 秒")
            success = conn.connect(server_ip, port, timeout=timeout)

            if success:
                log.info(f"成功连接到 SMB 服务器 {server_ip}，验证成功，即将关闭连接")
                conn.close()  # 验证成功后主动关闭连接
                return (True, 'SMB 服务可访问')
            else:
                log.warning(f"无法连接到 SMB 服务器 {server_ip}，验证失败")
                return (False, "SMB 服务不可访问")

        except socket.timeout:
            log.error(f"SMB 连接超时，服务器 IP: {server_ip}，可能是防火墙阻塞")
            return (False, "SMB 连接超时(防火墙阻塞?)")
        except socket.error as e:
            if "Connection refused" in str(e):
                log.error(f"连接被拒绝，服务器 IP: {server_ip}，端口可能关闭或服务未运行")
                return (False, "Port Closed/Service Not Running")
            elif "No route to host" in str(e):
                log.error(f"网络不可达，服务器 IP: {server_ip}")
                return (False, "Network Unreachable")
            else:
                log.error(f"网络错误，服务器 IP: {server_ip}，错误信息: {str(e)}")
                return (False, f"Network Error: {str(e)}")
        except Exception as e:
            log.error(f"发生意外错误，服务器 IP: {server_ip}，错误信息: {str(e)}")
            return (False, f"Unexpected Error: {str(e)}")

    def check_telnet_login(self,server_ip, port=23, timeout=5):
        """
        验证 Telnet 服务是否可以正常登录
        :param server_ip: Telnet 服务器 IP 地址
        :param port: Telnet 服务端口（默认 23）
        :param timeout: 连接超时时间（秒）
        :return: 元组 (是否成功连接, 返回信息)
        """
        log.info(f"开始验证 Telnet 服务登录，服务器 IP: {server_ip}，端口: {port}，超时时间: {timeout} 秒")
        try:
            # 创建 Telnet 连接对象
            log.debug(f"创建 Telnet 连接对象，准备连接到 {server_ip}:{port}")
            tn = telnetlib.Telnet()

            # 尝试建立连接
            log.debug(f"尝试连接到 {server_ip}:{port}，设置超时时间为 {timeout} 秒")
            tn.open(server_ip, port, timeout=timeout)
            log.info(f"成功连接到 Telnet 服务器 {server_ip}:{port}，即将关闭连接")
            tn.close()  # 连接成功后关闭连接
            return (True, "Telnet 服务可访问")

        except socket.timeout:
            log.error(f"Telnet 连接超时，服务器 IP: {server_ip}，端口: {port}，可能是防火墙阻塞")
            return (False, "telnet 连接超时 (防火墙阻塞?)")
        except socket.error as e:
            if "Connection refused" in str(e):
                log.error(f"连接被拒绝，服务器 IP: {server_ip}，端口: {port}，可能是服务未运行或端口关闭")
                return (False, "连接被拒绝 (服务未运行或端口关闭)")
            elif "No route to host" in str(e):
                log.error(f"网络不可达，服务器 IP: {server_ip}，端口: {port}")
                return (False, "网络不可达")
            else:
                log.error(f"网络错误，服务器 IP: {server_ip}，端口: {port}，错误信息: {str(e)}")
                return (False, f"网络错误: {str(e)}")
        except Exception as e:
            log.error(f"发生意外错误，服务器 IP: {server_ip}，端口: {port}，错误信息: {str(e)}")
            return (False, f"发生意外错误: {str(e)}")

    def check_ftp_login(self,server_ip, username='test123', password='Aa123456@', port=21, timeout=5):
        """
        验证 FTP 服务是否可以正常登录
        :param server_ip: FTP 服务器 IP 地址
        :param username: 登录用户名（默认使用匿名用户）
        :param password: 登录密码（默认为空）
        :param port: FTP 服务端口（默认 21）
        :param timeout: 连接超时时间（秒）
        :return: 元组 (是否成功连接, 返回信息)
        """
        log.info(f"开始验证 FTP 服务登录，服务器 IP: {server_ip}，用户名: {username}，端口: {port}，超时时间: {timeout} 秒")
        try:
            # 创建 FTP 连接对象
            log.debug(f"创建 FTP 连接对象，准备连接到 {server_ip}:{port}")
            ftp = FTP()

            # 设置连接超时时间
            log.debug(f"尝试连接到 {server_ip}:{port}，超时时间为 {timeout} 秒")
            ftp.connect(server_ip, port, timeout=timeout)
            log.info(f"成功连接到 FTP 服务器 {server_ip}:{port}")

            # 登录到 FTP 服务器
            log.debug(f"使用用户名 {username} 尝试登录到 FTP 服务器 {server_ip}:{port}")
            ftp.login(user=username, passwd=password)
            log.info(f"成功登录到 FTP 服务器 {server_ip}:{port}，用户名: {username}")

            # 登录成功后退出
            log.debug(f"登录成功，准备退出 FTP 服务器 {server_ip}:{port}")
            ftp.quit()
            log.info(f"已成功退出 FTP 服务器 {server_ip}:{port}")
            return (True, "FTP 服务可访问")

        except socket.timeout:
            log.error(f"FTP 连接超时，服务器 IP: {server_ip}，端口: {port}，可能是防火墙阻塞")
            return (False, "FTP 连接超时 (防火墙阻塞?)")
        except socket.error as e:
            if "Connection refused" in str(e):
                log.error(f"连接被拒绝，服务器 IP: {server_ip}，端口: {port}，可能是服务未运行或端口关闭")
                return (False, "连接被拒绝 (服务未运行或端口关闭)")
            elif "No route to host" in str(e):
                log.error(f"网络不可达，服务器 IP: {server_ip}，端口: {port}")
                return (False, "网络不可达")
            else:
                log.error(f"网络错误，服务器 IP: {server_ip}，端口: {port}，错误信息: {str(e)}")
                return (False, f"网络错误: {str(e)}")
        except error_perm as e:
            log.error(f"权限错误，服务器 IP: {server_ip}，端口: {port}，用户名: {username}，错误信息: {str(e)}")
            return (False, f"权限错误: {str(e)}")
        except Exception as e:
            log.error(f"发生意外错误，服务器 IP: {server_ip}，端口: {port}，用户名: {username}，错误信息: {str(e)}")
            return (False, f"发生意外错误: {str(e)}")

    def check_webdav_access(self, server,username, password, port=5005,timeout=10):
        """
        验证 WebDAV 服务是否可以正常访问
        :param server: WebDAV 服务器 IP 地址或主机名
        :param port: WebDAV 服务端口（默认 5005）
        :param username: 登录用户名（可选）
        :param password: 登录密码（可选）
        :param timeout: 请求超时时间（秒），默认 5 秒
        :return: 元组 (是否成功连接, 返回信息)
        """
        log.info(f"开始验证 WebDAV 服务访问，服务器: {server}，端口: {port}，用户名: {username}，超时时间: {timeout} 秒")
        url = f'http://{server}:{port}/'  # WebDAV 根路径
        log.debug(f"构建的 WebDAV 请求 URL 为: {url}")

        try:
            log.debug(f"准备发送 OPTIONS 请求到 {url}，设置超时时间为 {timeout} 秒，使用用户名: {username} 进行认证")
            # 发送 OPTIONS 请求，并设置超时时间
            response = requests.options(url, auth=(username, password), verify=False, timeout=timeout)
            log.debug(f"收到来自 {url} 的响应，状态码为: {response.status_code}")

            # 检查响应状态码
            if response.status_code == 200:
                log.info(f"WebDAV 服务可访问，服务器: {server}，端口: {port}")
                return (True, "WebDAV 服务可访问")
            else:
                log.warning(f"WebDAV 服务不可访问，服务器: {server}，端口: {port}，状态码: {response.status_code}")
                return (False, f"WebDAV 服务不可访问，状态码: {response.status_code}")

        except requests.ConnectionError as e:
            log.error(f"WebDAV 服务不可用，连接出错，服务器: {server}，端口: {port}，可能是防火墙阻塞，错误信息: {e}")
            return (False, "WebDAV 服务不可用，(防火墙阻塞?)")
        except requests.Timeout as e:
            log.error(f"WebDAV 服务请求超时，服务器: {server}，端口: {port}，可能是防火墙阻塞，错误信息: {e}")
            return (False, "WebDAV 服务不可用，(防火墙阻塞?)")
        except Exception as e:
            log.error(f"获取 WebDAV 接口出现其他异常，服务器: {server}，端口: {port}，错误信息: {e}")
            return (False, f"发生意外错误: {str(e)}")

    def check_rsync_access(self, server, username, password, module=None,port=873, timeout=5):
        """
        验证 rsync 服务是否可以正常访问
        :param server: rsync 服务器 IP 地址或主机名
        :param port: rsync 服务端口（默认 873）
        :param module: rsync 模块名（可选）
        :param username: 登录用户名
        :param password: 登录密码
        :param timeout: 执行 rsync 命令的超时时间（秒），默认 10 秒
        :return: 元组 (是否成功连接, 返回信息)
        """
        log.info(f"开始验证 rsync 服务访问，服务器: {server}，端口: {port}，模块: {module}，用户名: {username}，超时时间: {timeout} 秒")

        try:
            # 创建一个临时的密码文件
            log.debug(f"开始创建临时密码文件，用户名: {username}")
            with tempfile.NamedTemporaryFile(mode='w', delete=False) as temp:
                temp.write(f"{username}:{password}")
                temp_path = temp.name
            log.debug(f"临时密码文件创建成功，路径: {temp_path}")

            # 设置密码文件的权限为 600
            log.debug(f"设置临时密码文件 {temp_path} 的权限为 600")
            os.chmod(temp_path, 0o600)

            # 构建 rsync 命令
            log.debug("开始构建 rsync 命令")
            if module:
                command = ["rsync", f"--port={port}", f"--password-file={temp_path}", f"{username}@{server}::{module}",
                           "/dev/null"]
            else:
                command = ["rsync", f"--port={port}", f"--password-file={temp_path}", f"{username}@{server}::",
                           "/dev/null"]
            log.debug(f"rsync 命令构建完成: {' '.join(command)}")

            # 执行 rsync 命令，并设置超时时间
            log.debug(f"开始执行 rsync 命令，超时时间: {timeout} 秒")
            result = subprocess.run(command, stderr=subprocess.PIPE, stdout=subprocess.PIPE, timeout=timeout)

            # 删除临时密码文件
            log.debug(f"删除临时密码文件 {temp_path}")
            os.remove(temp_path)

            # 检查返回码
            if result.returncode == 0:
                log.info("rsync 服务可访问")
                return (True, "rsync 服务可访问")
            else:
                log.warning(f"rsync 服务不可用，返回码: {result.returncode}，可能是防火墙阻塞")
                return (False, f"rsync 服务不可用，(防火墙阻塞?)")

        except subprocess.TimeoutExpired:
            log.error(f"执行 rsync 命令超时，超时时间: {timeout} 秒，可能是防火墙阻塞")
            # 删除临时密码文件（如果超时，可能之前未删除）
            if os.path.exists(temp_path):
                log.debug(f"删除因超时而未删除的临时密码文件 {temp_path}")
                os.remove(temp_path)
            return (False, f"执行 rsync 命令超时，(防火墙阻塞?)")
        except Exception as e:
            log.error(f"发生意外错误: {e}")
            # 删除临时密码文件（如果发生其他异常，可能之前未删除）
            if os.path.exists(temp_path):
                log.debug(f"删除因异常而未删除的临时密码文件 {temp_path}")
                os.remove(temp_path)
            return (False, f"发生意外错误: {str(e)}")

    def check_wsdd2_access(self,server, port=3702):
        """
        验证 wsdd2 服务是否可以正常访问
        :param server: wsdd2 服务器 IP 地址或主机名
        :param port: wsdd2 服务端口（默认 3702）
        :return: 元组 (是否成功连接, 返回信息)
        """
        log.info(f"开始验证 wsdd2 服务访问，服务器: {server}，端口: {port}")
        try:
            # 创建一个 socket 对象
            log.debug("开始创建 socket 对象")
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
                log.debug("socket 对象创建成功")
                # 设置超时时间
                log.debug(f"设置 socket 超时时间为 5 秒")
                sock.settimeout(5)
                # 尝试连接到 wsdd2 服务
                log.debug(f"尝试连接到 {server}:{port}")
                result = sock.connect_ex((server, port))
                log.debug(f"连接结果返回码: {result}")

                # 检查连接结果
                if result == 0:
                    log.info("wsdd2 服务可访问")
                    return (True, "wsdd2 服务可访问")
                else:
                    log.warning(f"wsdd2 服务不可用，连接结果返回码: {result}，可能是防火墙阻塞")
                    return (False, f"wsdd2 服务不可用，(防火墙阻塞?)")

        except Exception as e:
            log.error(f"发生意外错误，服务器: {server}，端口: {port}，错误信息: {e}")
            return (False, f"发生意外错误: {str(e)}")

    @check_response(ext="data.list", check=assert_message)
    def get_firewall_application(self,sections=[]):
        """
        获取防火墙的内置服务信息
        """
        log.debug(f"开始执获取防火墙的内置服务信息")
        path = "/ugreen/v1/security/firewall/application"
        data = {"sections":sections}
        try:
            response = self.http.post(path,json=data)
            return response
        except Exception as e:
            log.error(f"在获取防火墙的内置服务信息过程中出现异常，异常信息: {e}")
            raise

    def application_info_by_service_name(self, service_name):
        """
        根据服务名称获取某一个内置服务信息
        :param service_name: 服务名称  SSH 、UGOS Pro、FTP、NFS、WebDAV、wsdd2、Telnet、rsync、SMB

        """
        log.debug(f"开始执行根据服务名称获取某一个内置服务信息，服务名称: {service_name}")
        try:
            results = self.get_firewall_application()
            # 性能优化：将结果转换为字典
            service_dict = {result["name"]: result for result in results}
            if service_name in service_dict:
                log.info(f"成功找到服务 {service_name} 的信息")
                return service_dict[service_name]
            else:
                log.warning(f"未找到服务名称为 {service_name} 的内置服务信息")
                return None
        except KeyError as ke:
            log.error(f"在根据服务名称获取信息时，结果字典中缺少必要的键，异常信息: {ke}")
        except Exception as e:
            log.error(f"在根据服务名称获取某一个内置服务信息过程中出现异常，异常信息: {e}")
        return None

if __name__ == '__main__':
    config = Config(config_name=config_name)
    login = Login(config_name=config_name)
    token = login.login()
    host_list = config.read_config_ini('envHost', 'host_list').split(',')
    api = NetworkApi(token)
    a = api.check_ssh_login('172.17.21.133','test123','Aa123456@')
    print(a)
    b = api.check_smb_login('172.17.21.133', 'test123', 'Aa123456@')
    print(b)
    c = api.check_telnet_login('172.17.21.133',port=24694)
    print(c)
    d = api.check_ftp_login('172.17.21.133',username='test123',password='Aa123456@',port=256)
    print(d)
    e = api.check_webdav_access('172.17.21.133', username='test123', password='Aa123456@',port=5005)
    print(e)
    f = api.check_rsync_access('172.17.21.133', username='test123',password='Aa123456@',port=48954)
    print(f)
    g = api.check_wsdd2_access('172.17.20.252')
    print(g)
    h = api.check_http('172.17.21.133','test123')
    print(h)
    # network = Network()
    # ip = network.get_ip_by_prefix('172.17.60','DXP8800PRO-A415',thread_num=20)
    # print(ip)
